import pandas as pd
import re
from datetime import datetime

# 读取文件
dou1 = pd.read_excel(r'G:\工作\每日\抖音1.xlsx')
dou2 = pd.read_excel(r'G:\工作\每日\抖音2.xlsx')
dou3 = pd.read_excel(r'G:\工作\每日\抖音3.xlsx')
dou4 = pd.read_excel(r'G:\工作\每日\抖音4.xlsx')
jd = pd.read_excel(r'G:\工作\每日\JD.xlsx')
jd_qc = jd.drop_duplicates(subset=['订单号'])  # 订单编号去重，统计销售额
jd1 = pd.read_excel(r'G:\工作\每日\JD1.xlsx')
jd1_qc = jd1.drop_duplicates(subset=['订单号'])  # 订单编号去重，统计销售额
pdd1 = pd.read_excel(r'G:\工作\每日\PDD1.xlsx')
pdd2 = pd.read_excel(r'G:\工作\每日\PDD2.xlsx')
pdd3 = pd.read_excel(r'G:\工作\每日\PDD3.xlsx')
pdd4 = pd.read_excel(r'G:\工作\每日\PDD4.xlsx')
pdd6 = pd.read_excel(r'G:\工作\每日\PDD6.xlsx')
pdd5 = pd.read_excel(r'G:\工作\每日\PDD5.xlsx')
ks1 = pd.read_excel(r'G:\工作\每日\快手1.xlsx')
ks2 = pd.read_excel(r'G:\工作\每日\快手2.xlsx')
ks3 = pd.read_excel(r'G:\工作\每日\快手3.xlsx')
xhs = pd.read_excel(r'G:\工作\每日\小红书.xlsx')
sph = pd.read_excel(r'G:\工作\每日\视频号.xlsx')
sph_qc = sph.drop_duplicates(subset=['订单号'])
tm = pd.read_excel(r'G:\工作\每日\天猫.xlsx')
tcc = pd.read_excel(r'G:\工作\每日\淘宝买菜.xlsx')
tgc = pd.read_excel(r'G:\工作\每日\淘工厂.xlsx')
tgc2 = pd.read_excel(r'G:\工作\每日\淘工厂2.xlsx')

# 提取对应列
dou1_date = dou1.loc[
    :, ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '订单提交时间', '平台实际承担优惠金额',
        '达人实际承担优惠金额']]
dou1_date['平台'] = '抖音1'

dou2_date = dou2.loc[
    :, ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '订单提交时间', '平台实际承担优惠金额',
        '达人实际承担优惠金额']]
dou2_date['平台'] = '抖音2'

dou3_date = dou3.loc[
    :, ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '订单提交时间', '平台实际承担优惠金额',
        '达人实际承担优惠金额']]
dou3_date['平台'] = '抖音3'

dou4_date = dou4.loc[
    :, ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '订单提交时间', '平台实际承担优惠金额',
        '达人实际承担优惠金额']]
dou4_date['平台'] = '抖音4'

dou = pd.concat([dou1_date, dou2_date, dou3_date, dou4_date])
dou['订单应付金额加优惠'] = dou['订单应付金额'] + dou['平台实际承担优惠金额'] + dou['达人实际承担优惠金额']
dou_date = dou.loc[
    :, ['商家编码', '商品数量', '订单应付金额加优惠', '订单状态', '售后状态', '订单应付金额加优惠', '订单提交时间',
        '平台']]
dou_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

jd['平台'] = '京东旗舰店'
jd_qc['平台'] = '京东旗舰店'

jd1['平台'] = '京东旗舰店2'
jd1_qc['平台'] = '京东旗舰店2'

jd_date1 = pd.concat([jd, jd1])

jd_date = jd_date1.loc[:, ['商家SKUID', '订购数量', '结算金额', '订单状态', '订单状态', '结算金额', '下单时间', '平台']]
jd_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

jd_xse1 = pd.concat([jd_qc, jd1_qc])
jd_xse = jd_xse1.loc[:, ['商家SKUID', '订购数量', '结算金额', '订单状态', '订单状态', '结算金额', '下单时间', '平台']]
jd_xse.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

pdd1_date = pdd1.loc[
    :, ['商家编码-规格维度', '商品数量(件)', '商家实收金额(元)', '订单状态', '售后状态', '商家实收金额(元)',
        '支付时间']]
pdd1_date['平台'] = '拼多多1店'
pdd1_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']
pdd2_date = pdd2.loc[
    :, ['商家编码-规格维度', '商品数量(件)', '商家实收金额(元)', '订单状态', '售后状态', '商家实收金额(元)',
        '支付时间']]
pdd2_date['平台'] = '拼多多2店'
pdd2_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

pdd3_date = pdd3.loc[
    :, ['商家编码-规格维度', '商品数量(件)', '商家实收金额(元)', '订单状态', '售后状态', '商家实收金额(元)',
        '支付时间']]
pdd3_date['平台'] = '拼多多3店'
pdd3_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

pdd4_date = pdd4.loc[
    :, ['商家编码-规格维度', '商品数量(件)', '商家实收金额(元)', '订单状态', '售后状态', '商家实收金额(元)',
        '支付时间']]
pdd4_date['平台'] = '拼多多4店'
pdd4_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

pdd6_date = pdd6.loc[
    :, ['商家编码-规格维度', '商品数量(件)', '商家实收金额(元)', '订单状态', '售后状态', '商家实收金额(元)',
        '支付时间']]
pdd6_date['平台'] = '拼多多6店'
pdd6_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

pdd5_date = pdd5.loc[
    :, ['商家编码-规格维度', '商品数量(件)', '商家实收金额(元)', '订单状态', '售后状态', '商家实收金额(元)',
        '支付时间']]
pdd5_date['平台'] = '拼多多5店'
pdd5_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

ks1_date = ks1.loc[
    :, ['SKU编码', '成交数量', '实付款', '订单状态', '售后状态', '实付款', '订单创建时间']]  # 2月27日 退货退款列改为售后状态
ks1_date['平台'] = '快手1'
ks1_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']
ks1_date['订单应付金额'] = ks1_date['订单应付金额'].map(lambda x: float(str(x).replace('¥', '')))  ##去除￥符号
ks1_date['退款金额'] = ks1_date['退款金额'].map(lambda x: float(str(x).replace('¥', '')))  ##去除￥符号

ks2_date = ks2.loc[
    :, ['SKU编码', '成交数量', '实付款', '订单状态', '售后状态', '实付款', '订单创建时间']]  # 2月27日 退货退款列改为售后状态
ks2_date['平台'] = '快手2'
ks2_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']
ks2_date['订单应付金额'] = ks2_date['订单应付金额'].map(lambda x: float(str(x).replace('¥', '')))  ##去除￥符号
ks2_date['退款金额'] = ks2_date['退款金额'].map(lambda x: float(str(x).replace('¥', '')))  ##去除￥符号

ks3_date = ks3.loc[
    :, ['SKU编码', '成交数量', '实付款', '订单状态', '售后状态', '实付款', '订单创建时间']]  # 2月27日 退货退款列改为售后状态
ks3_date['平台'] = '快手3'
ks3_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']
ks3_date['订单应付金额'] = ks3_date['订单应付金额'].map(lambda x: float(str(x).replace('¥', '')))  ##去除￥符号
ks3_date['退款金额'] = ks3_date['退款金额'].map(lambda x: float(str(x).replace('¥', '')))  ##去除￥符号

xhs_date = xhs.loc[
    :, ['商家编码', 'SKU件数', '商家应收金额(元)（支付金额）', '订单状态', '售后状态', '商家应收金额(元)（支付金额）',
        '订单创建时间']]
xhs_date['平台'] = '小红书'
xhs_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

sph_date = sph.loc[
    :, ['SKU编码(自定义)', '商品数量', '订单实际支付金额', '订单状态', '商品售后', '商品已退款金额', '订单下单时间']]
sph_date['平台'] = '视频号'
sph_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

sph_xse = sph_qc.loc[
    :, ['SKU编码(自定义)', '商品数量', '订单实际支付金额', '订单状态', '商品售后', '商品已退款金额', '订单下单时间']]
sph_xse['平台'] = '视频号'
sph_xse.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

tm_date = tm.loc[:, ['商家编码', '购买数量', '买家实付金额', '订单状态', '退款状态', '退款金额', '订单创建时间']]
tm_date['平台'] = '天猫旗舰店'
tm_date['退款金额'] = tm_date['退款金额'].map(lambda x: float(str(x).replace('无退款申请', '0')))  # 替换无退款申请
tm_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

tcc_date = tcc.loc[:, ['商家编码', '宝贝数量', '子单实际支付金额', '订单状态', '订单状态', '退款金额', '订单创建时间']]
tcc_date['平台'] = '淘宝买菜'
tcc_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

tgc_date = tgc.loc[:, ['商家编码', '宝贝数量', '子单实际支付金额', '订单状态', '订单状态', '退款金额', '订单创建时间']]
tgc_date['平台'] = '淘工厂'
tgc_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

tgc2_date = tgc2.loc[
    :, ['商家编码', '宝贝数量', '子单实际支付金额', '订单状态', '订单状态', '退款金额', '订单创建时间']]
tgc2_date['平台'] = '淘宝买菜'
tgc2_date.columns = ['商家编码', '商品数量', '订单应付金额', '订单状态', '售后状态', '退款金额', '日期', '平台']

# 合并数据
date_concat = pd.concat(
    [
        dou_date, jd_xse,
        pdd1_date, pdd2_date, pdd3_date, pdd4_date,
        pdd6_date, pdd5_date,
        ks1_date, ks2_date, ks3_date,
        xhs_date, sph_xse,
        tm_date, tcc_date,
        tgc_date, tgc2_date
    ]
)  # 销售额，

date_concat_1 = pd.concat(
    [
        dou_date, jd_date,
        pdd1_date, pdd2_date, pdd3_date, pdd4_date, pdd6_date, pdd5_date,
        ks1_date, ks2_date, ks3_date,
        xhs_date, sph_date,
        tm_date, tcc_date,
        tgc_date, tgc2_date
    ]
)  # 订单件数 单量

# ['商家编码']去空格
date_concat['商家编码'] = date_concat['商家编码'].str.strip()
date_concat_1['商家编码'] = date_concat_1['商家编码'].str.strip()

# 去掉 '商家编码' 为空的
date_concat.dropna(subset=['商家编码'], inplace=True)

date_concat_1.dropna(subset=['商家编码'], inplace=True)
date_concat_1 = date_concat_1.applymap(lambda x: str(x).strip())
date_concat_1['日期'] = date_concat_1['日期'].replace("", '1998-01-01 00:00:00')
date_concat_1['日期'] = pd.to_datetime(date_concat_1['日期'])
date_concat_1['日期'] = date_concat_1['日期'].map(lambda x: datetime.date(x))
date_concat_1['商品数量'] = date_concat_1['商品数量'].map(lambda x: int(float(x)))
date_concat_1['订单应付金额'] = date_concat_1['订单应付金额'].map(lambda x: float(x))
date_concat_1['退款金额'] = date_concat_1['退款金额'].map(lambda x: float(x))

date_concat = date_concat.applymap(lambda x: str(x).strip())
date_concat['日期'] = date_concat['日期'].replace("", '1998-01-01 00:00:00')
date_concat['日期'] = pd.to_datetime(date_concat['日期'])
date_concat['日期'] = date_concat['日期'].map(lambda x: datetime.date(x))
date_concat['商品数量'] = date_concat['商品数量'].map(lambda x: int(float(x)))
date_concat['订单应付金额'] = date_concat['订单应付金额'].map(lambda x: float(x))
date_concat['退款金额'] = date_concat['退款金额'].map(lambda x: float(x))

# 筛选发货订单，不去掉金额<=0.01,和赠品  单量，去掉退货成功的
date_concat_dl = date_concat_1[(date_concat_1['订单状态'] == '部分发货') | (date_concat_1['订单状态'] == '待发货') | (
        date_concat_1['订单状态'] == '待配货') | (date_concat_1['订单状态'] == '等待确认收货') | (
                                       date_concat_1['订单状态'] == '交易成功') |
                               (date_concat_1['订单状态'] == '卖家已发货，等待买家确认') | (
                                       date_concat_1['订单状态'] == '已发货') | (
                                       date_concat_1['订单状态'] == '已发货，待签收') | (
                                       date_concat_1['订单状态'] == '已发货未签收') | (
                                       date_concat_1['订单状态'] == '已完成')
                               | (date_concat_1['订单状态'] == '已支付') | (date_concat_1['订单状态'] == '已签收') | (
                                       date_concat_1['订单状态'] == '买家已付款，等待卖家发货') | (
                                       date_concat_1['订单状态'] == '等待出库') | (
                                       date_concat_1['订单状态'] == '(锁定)等待确认收货')
                               | (date_concat_1['订单状态'] == '完成') | (
                                       date_concat_1['订单状态'] == '已发货，待收货') | (
                                       date_concat_1['订单状态'] == '已收货') | (
                                       date_concat_1['订单状态'] == '卖家部分发货') | (
                                       date_concat_1['订单状态'] == '买家已付款,等待卖家发货')
                               | (date_concat_1['订单状态'] == '卖家已发货') | (
                                       date_concat_1['订单状态'] == '买家已付款') | (
                                       date_concat_1['订单状态'] == '发货即将超时') | (
                                       date_concat_1['订单状态'] == '交易成功') | (
                                       date_concat_1['订单状态'] == '待买家收货') | (
                                       date_concat_1['订单状态'] == '待卖家发货') | (
                                       date_concat_1['订单状态'] == '部分发货中')]
date_concat_dl = date_concat_dl[
    (date_concat_dl['售后状态'] != '退款成功') & (date_concat_dl['售后状态'] != '退款完成') & (
            date_concat_dl['售后状态'] != '已全额退款') & (date_concat_dl['售后状态'] != '(删除)等待出库') & (
            date_concat_dl['售后状态'] != '(删除)等待确认收货') & (date_concat_dl['售后状态'] != '售后完成')]
date_concat_dl = date_concat_dl[
    (date_concat_dl['商家编码'] != '抖音直播间赠品') | (date_concat_dl['商家编码'] != 'logo定制电煮锅1个') | (
            date_concat_dl['商家编码'] != '红色电煮锅1个')]
date_concat_dl = date_concat_dl.groupby([date_concat_dl['日期'], date_concat_dl['平台'], date_concat_dl['商家编码']],
                                        as_index=False).agg(商品数量=('商品数量', 'sum'))
# date_concat_dl.to_excel(r'G:\结果\结果_待发货(单量).xlsx')

# 筛选发货订单，去掉金额<=0.01,和赠品  销售额,去掉退货成功的
date_concat_s = date_concat[(date_concat['订单状态'] == '部分发货') | (date_concat['订单状态'] == '待发货') | (
        date_concat['订单状态'] == '待配货') | (date_concat['订单状态'] == '等待确认收货') | (
                                    date_concat['订单状态'] == '交易成功') |
                            (date_concat['订单状态'] == '卖家已发货，等待买家确认') | (
                                    date_concat['订单状态'] == '已发货') | (
                                    date_concat['订单状态'] == '已发货，待签收') | (
                                    date_concat['订单状态'] == '已发货未签收') |
                            (date_concat['订单状态'] == '已完成') | (date_concat['订单状态'] == '已支付') | (
                                    date_concat['订单状态'] == '已签收') | (
                                    date_concat['订单状态'] == '买家已付款，等待卖家发货') | (
                                    date_concat['订单状态'] == '等待出库')
                            | (date_concat['订单状态'] == '(锁定)等待确认收货') | (
                                    date_concat['订单状态'] == '完成') | (
                                    date_concat['订单状态'] == '已发货，待收货') | (
                                    date_concat['订单状态'] == '已收货') | (
                                    date_concat['订单状态'] == '卖家部分发货') | (
                                    date_concat['订单状态'] == '买家已付款,等待卖家发货')
                            | (date_concat['订单状态'] == '卖家已发货') | (date_concat['订单状态'] == '买家已付款') | (
                                    date_concat['订单状态'] == '发货即将超时') | (
                                    date_concat['订单状态'] == '交易成功') | (
                                    date_concat['订单状态'] == '待买家收货') | (
                                    date_concat['订单状态'] == '待卖家发货') | (
                                    date_concat['订单状态'] == '部分发货中')]
date_concat_ss = date_concat_s[(date_concat_s['订单应付金额'] >= 0.01)]
date_concat_sss = date_concat_ss[(date_concat_ss['商家编码'] != '抖音直播间赠品')]
date_concat_sss = date_concat_sss[
    (date_concat_sss['售后状态'] != '退款成功') & (date_concat_sss['售后状态'] != '退款完成') & (
            date_concat_sss['售后状态'] != '已全额退款') & (date_concat_sss['售后状态'] != '(删除)等待出库') & (
            date_concat_sss['售后状态'] != '(删除)等待确认收货') & (date_concat_sss['售后状态'] != '售后完成') & (
            date_concat_sss['售后状态'] != '退货退款完成')]

# date_concat_sss = date_concat_sss.groupby([
#     date_concat_sss['日期'],
#     date_concat_sss['平台'],
#     date_concat_sss['商家编码']
# ], as_index=False).agg(
#     商品数量=('商品数量', 'sum'),
#     订单应付金额=('订单应付金额', 'sum')
# )
# date_concat_sss.to_excel(r'G:\结果\结果_待发货(销售额)1.xlsx')


# 分类汇总销售金额
result_sale = date_concat_sss.groupby([
    date_concat_sss['日期'],
    date_concat_sss['平台']
]).agg(
    订单应付金额=('订单应付金额', 'sum'),
    商品数量=('商品数量', 'count'))

# 退款
date_concat_td = date_concat[(date_concat['售后状态'] == '退款成功') | (date_concat['售后状态'] == '退款完成') | (
        date_concat['售后状态'] == '已全额退款') | (date_concat['售后状态'] == '(删除)等待出库') | (
                                     date_concat['售后状态'] == '(删除)等待确认收货') | (
                                     date_concat['售后状态'] == '售后完成') | (
                                     date_concat['售后状态'] == '退货退款完成') | (
                                     date_concat['售后状态'] == '交易关闭')]
# 分类汇总退款金额
result_td_sale = date_concat_td['退款金额'].groupby([date_concat_td['日期'], date_concat_td['平台']]).sum()

# 整合表
ress = pd.concat([result_sale, result_td_sale], axis=1)
ress.columns = ['销售额', '销售单量', '退款金额']
ress.fillna(0, inplace=True)
ress['总销售额'] = ress['销售额'] + ress['退款金额']
# re.to_excel(r'G:\结果\线上销售额汇总_11月.xlsx')

# 读取文件
douchao = pd.read_excel(r'G:\工作\每日\抖超.xlsx')

maochao = pd.read_excel(r'G:\工作\每日\猫超.xlsx')
ziying1 = pd.read_excel(r'G:\工作\每日\自营1.xlsx')
ziying2 = pd.read_excel(r'G:\工作\每日\自营2.xlsx')
ziying2_dl = pd.read_excel(r'G:\工作\每日\自营2.xlsx')
pp = pd.read_excel(r'G:\工作\猫超+自营SKU编码.xlsx', dtype={'SKU': str})

douchao['退款成功金额'] = 0
douchao['平台'] = '抖音超市'
douchao['月'] = douchao['日期'].map(lambda x: str(x)[0:8])
douchao_date = douchao.loc[
    :, ['月', '货品ID', '支付货品件数', '支付GMV', '退款成功金额', '支付货品件数', '平台', '货品名']]  # 无退款
douchao_date.columns = ['日期', 'SKU', '销售单量', '销售额', '退款金额', '成交商品件数', '平台', '产品名称']

maochao['商品数量'] = maochao['支付商品件数'] - maochao['退款成功商品件数']
maochao['平台'] = '猫超'
maochao['月'] = maochao['统计日期'].map(lambda x: str(x)[0:8])
maochao_date = maochao.loc[
    :, ['月', '商品ID', '支付子订单数(剔退款)', '支付金额(剔退款)', '退款成功金额', '商品数量', '平台']]
maochao_date.columns = ['日期', 'SKU', '销售单量', '销售额', '退款金额', '成交商品件数', '平台']

ziying1['退款成功金额'] = 0
ziying1['平台'] = '京东自营1'
ziying1_date = ziying1.loc[:, ['时间', 'SKU', '成交单量', '成交金额', '退款成功金额', '成交商品件数', '平台']]
ziying1_date.columns = ['日期', 'SKU', '销售单量', '销售额', '退款金额', '成交商品件数', '平台']

ziying2 = ziying2[
    (ziying2['SKU'] != 100095090135) & (ziying2['SKU'] != 100111765304) & (ziying2['SKU'] != 100111765306) & (
            ziying2['SKU'] != 100122053209)]
ziying2['退款成功金额'] = 0
ziying2['平台'] = '京东自营2'
ziying2_date = ziying2.loc[:, ['时间', 'SKU', '成交单量', '成交金额', '退款成功金额', '成交商品件数', '平台']]
ziying2_date.columns = ['日期', 'SKU', '销售单量', '销售额', '退款金额', '成交商品件数', '平台']

ziying2_dl['退款成功金额'] = 0
ziying2_dl['平台'] = '京东自营2'
ziying2dl_date = ziying2_dl.loc[:, ['时间', 'SKU', '成交单量', '成交金额', '退款成功金额', '成交商品件数', '平台']]
ziying2dl_date.columns = ['日期', 'SKU', '销售单量', '销售额', '退款金额', '成交商品件数', '平台']

res = pd.concat([maochao_date, ziying1_date, ziying2_date])

# ['商家编码']去空格
res['SKU'] = res['SKU'].astype(str).str.strip()
res_m = pd.merge(res, pp, on=['SKU'], how='left')

result = pd.concat([res_m, douchao_date])

result_mc = result[['销售额', '销售单量', '退款金额']].groupby([result['日期'], result['平台']]).sum()

# 销售额汇总总结果
result_sales = pd.concat([ress, result_mc])
result_sales.to_excel(r'G:\结果\销售额汇总.xlsx')

res_dl = pd.concat([maochao_date, ziying1_date, ziying2dl_date])

# ['商家编码']去空格
res_dl['SKU'] = res_dl['SKU'].astype(str).str.strip()
res_mdl = pd.merge(res_dl, pp, on=['SKU'], how='left')

mc = pd.concat([res_mdl, douchao_date])

pp = pd.read_excel(r'G:\工作\商家编码匹配产品.xlsx')  # 匹配表
pp_zh = pd.read_excel(r'G:\工作\商家编码匹配产品.xlsx', sheet_name='组合装')  # 匹配表
mc = mc[mc['成交商品件数'] > 0]
mc_date = mc.loc[:, ['日期', '产品名称', '成交商品件数', '平台']]
mc_date.columns = ['日期', '商家编码', '商品数量', '平台1']
mc_date['平台'] = mc_date['平台1']

xs = date_concat_dl
xs_date = xs.loc[:, ['日期', '商家编码', '商品数量', '平台']]
xs_date['平台1'] = '线上'
result = pd.concat([xs_date, mc_date])
result_1 = pd.concat([xs_date, mc_date])  # 用于提取组合装

# ['商家编码']去空格
result['商家编码'] = result['商家编码'].str.strip()
# 去空值
result.dropna(subset=['商家编码'], inplace=True)
# 去掉抖音直播间赠品，电煮锅，空值
result = result[(result['商家编码'] != 'logo定制电煮锅1个') & (result['商家编码'] != '抖音直播间赠品') & (
        result['商家编码'] != '赠品') & (result['商家编码'] != '红色电煮锅1个')]

# 所有产品，包含组合装
# 处理每行多订单情况
# 分列
s_1 = []  # 分列后以列表形式保存
r_1 = []  # 添加每个分列后的产品
r_3 = []  # 添加商品数量
r_4 = []  # 添加平台
r_5 = []  # 添加平台1 线上
r_6 = []  # 添加月
for date_s in list(result['商家编码']):
    if '+' in date_s:
        date_split = str(date_s).split('+')
        s_1.append(date_split)

    elif '，' in date_s:
        date_split = str(date_s).split('，')
        if '赠' in date_split[0]:
            date_split_1 = date_split[0].split('赠')
            s_1.append(date_split_1)
        else:
            s_1.append([date_split[0]])
    elif '赠' in date_s:
        date_split = str(date_s).split('赠')
        s_1.append(date_split)
    elif '＋' in date_s:
        date_split = str(date_s).split('＋')
        s_1.append(date_split)
    else:
        s_1.append([date_s])

result['编码分裂'] = s_1

date_concat_s = result.reset_index(drop=True)

n = 0
for i in list(date_concat_s['编码分裂']):

    # 查i对应的索引值
    # n=list(date_concat['编码分裂']).index(i)
    # 分裂后生成的是列表，所以用列表长度判定
    if len(i) == 1:  # 判定是否有多的订单
        r_1.append(i[0])
        r_3.append(list(date_concat_s['商品数量'])[n])
        r_4.append(list(date_concat_s['平台'])[n])
        r_5.append(list(date_concat_s['平台1'])[n])
        r_6.append(list(date_concat_s['日期'])[n])

    else:  # 多订单的情况下分行并对应单量
        for c in i:
            r_1.append(c)
            r_3.append(list(date_concat_s['商品数量'])[n])
            r_4.append(list(date_concat_s['平台'])[n])
            r_5.append(list(date_concat_s['平台1'])[n])
            r_6.append(list(date_concat_s['日期'])[n])

    n += 1
s = {'日期': r_6, '商家编码': r_1, '商品数量': r_3, '平台': r_4, '平台1': r_5}
res_d = pd.DataFrame(s)
# res.to_excel(r'G:\结果\分列4.xlsx')

# 处理土豆粉出单

result_hz = res_d.groupby([res_d['日期'], res_d['平台1'], res_d['平台'], res_d['商家编码']], as_index=False).sum()
result_tdf = result_hz.copy()
res_pp = pd.merge(result_hz, pp, on=['商家编码'], how='left')

# 组合装处理
res_zh = pd.merge(result_1, pp_zh, on=['商家编码'], how='left')
res_zh.dropna(subset=['产品'], inplace=True)

result_re = pd.concat([res_pp, res_zh], axis=0)


# 提取商品袋数
def d(x):
    if '袋' in x:
        return re.findall(r"(\d+)袋", x)[-1]
    elif '桶' in x:
        return re.findall(r"(\d+)桶", x)[-1]
    elif ('个' in x):
        try:
            return re.findall(r"(\d+)个", x)[-1]
        except:
            return 1

    elif '包' in x:
        return re.findall(r"(\d+)包", x)[-1]
    elif ('只' in x):
        return re.findall(r"(\d+)只", x)[-1]
    elif ('根' in x):
        return re.findall(r"(\d+)根", x)[-1]
    else:
        return 0


# 处理总
result_re_zong = result_re.loc[result_re['单位'] == '总', :].copy()
result_re_zong['件数'] = 1
# 处理分
result_re_fen = result_re.loc[result_re['单位'] != '总', :].copy()
result_re_fen['件数'] = result_re_fen['商家编码'].map(d)

result_re_fen['件数'] = result_re_fen['件数'].astype(int)

# 处理未匹配上的
# result_re_na=result_re.loc[result_re['单位'].isnull(),:].copy()
# result_re_na['件数']='手动处理'


result_res = pd.concat([result_re_zong, result_re_fen], axis=0)
result_res['总件数'] = result_res['商品数量'] * result_res['件数']
result_res.to_excel(r'G:\结果\产品订单量结果_新.xlsx',index=False)  # 单品出单汇总

# 判定产品类别  如果出现新品 g+名称

def f(x):
    if '+' in x or ('80g*土豆粉' in x):
        return '其他'

    elif '窝子面' in x:
        return '窝子面'
    elif '140g火鸡面' in x or ('火鸡面' in x):
        return '140g火鸡面'
    elif '436g' in x or ('螺蛳粉' in x) or ('436螺蛳' in x):
        return '436g螺蛳粉土豆粉版'

    elif '粉面两掺' in x:
        return '粉面两掺'
    elif '133g袋装' in x or ('133g' in x):
        return '袋装板面'

    elif '板面桶装' in x:
        return '桶装板面'
    elif '乐享杯' in x:
        return '乐享杯桶装'
    elif '家庭版袋装米线' in x or '家庭版' in x or '家庭麻酱米线' in x or '乐享版家庭' in x:
        return '家庭版麻酱米线'
    elif '欢享土豆粉' in x or '欢享版土豆粉' in x or '欢享版土豆' in x:
        return '欢享土豆粉'
    elif '轻享版' in x:
        return '轻享土豆粉'
    elif ('乐享版刀削面' in x) or ('乐享刀削面' in x):
        return '乐享刀削面'
    elif ('乐享版土豆粉' in x) or ('乐享土豆粉' in x) or ('286g' in x):
        return '乐享土豆粉'
    elif '荆芥土豆粉' in x:
        return '荆芥土豆粉'
    elif '荆芥麻酱米线' in x or ('荆芥袋装米线' in x):
        return '荆芥米线'
    elif ('肥汁米线桶装' in x) or ('肥汁桶装' in x):
        return '肥汁桶装'

    elif ('麻辣米线' in x):
        return '麻辣米线'

    elif '117g肥汁' in x or ('肥汁米线117g' in x):
        return '117g肥汁米线'
    elif '203g肥汁' in x or ('肥汁米线203g' in x):
        return '203g肥汁米线'
    elif '线下肥汁' in x:
        return '线下肥汁米线'
    elif '80g土豆粉' in x or ('土豆粉80g' in x):
        return '其他'
    elif '板面底料1桶' in x or ('板面调料' in x):
        return '其他'
    elif x == '青春龙年礼盒':
        return '经典土豆粉'
    elif ('土豆粉') in x or ('士豆粉' in x):
        return '经典土豆粉'
    elif '豆芽板面' in x or ('166g' in x):
        return '豆芽板面'
    elif '板面' in x or ('146g' in x):
        return '桶装板面'
    elif '桶' in x:
        return '石磨桶装'
    elif ('石磨' in x) or ('经典' in x) or ('麻酱' in x) or ('传统' in x) or ('青春' in x) or ('麻辣' in x) or (
            '来点尝一尝' in x) or ('01款' in x) or ('联名' in x):
        return '袋装米线'
    elif '刀削面面饼' in x:
        return '其他'
    elif '刀削面' in x:
        return '刀削面'
    elif '烩面' in x:
        return '炝锅烩面'
    else:
        return '其他'


result_tdf['分类'] = result_tdf['商家编码'].map(f)


# 提取件数
def m(x):
    if x == '土豆粉龙年礼盒' or x == '青春龙年礼盒':
        return 6
    elif x == '刀削面龙年礼盒':
        return 3
    elif '烩面龙年礼盒' in x:
        return 6

    elif ('乐享版' in x) or ('轻享版' in x):
        try:
            return re.findall(r"(\d+)袋", x)[-1]
        except:
            return 0
    elif '土豆粉' in x or ('士豆粉' in x) or ('粉面两掺' in x):
        try:
            return re.findall(r"(\d+)袋", x)[-1]
        except:
            return 0
    elif '桶' in x:
        try:
            return re.findall(r"(\d+)桶", x)[-1]
        except:
            return 0
    elif ('石磨' in x) or ('经典' in x) or ('麻酱' in x) or ('传统' in x) or ('青春' in x) or ('麻辣' in x) or (
            '来点尝一尝' in x) or ('联名' in x) or ('荆芥' in x) or ('袋装米线' in x) or ('肥汁' in x):

        try:
            return re.findall(r"(\d+)袋", x)[-1]
        except:
            return 0
    elif '01款' in x:
        return 1
    elif ('刀削面' in x) or ('烩面' in x) or ('板面' in x):
        try:
            return re.findall(r"(\d+)袋", x)[-1]
        except:
            return 0
    else:
        return 0


result_tdf['件数'] = result_tdf['商家编码'].map(m)
result_tdf['件数'] = result_tdf['件数'].astype(int)
result_tdf['总件数'] = result_tdf['件数'] * result_tdf['商品数量']
# result_tdf.to_excel(r'G:\结果\土豆粉出单线上_新.xlsx')

result_ = result_tdf.groupby(
    [
        result_tdf['日期'],
        result_tdf['平台'],
        result_tdf['平台1'],
        result_tdf['商家编码'],
        result_tdf['分类']],
    as_index=False).agg(
    总件数=('总件数', 'sum')
)
# result_.to_excel(r'G:\结果\土豆粉出单线上汇总.xlsx')
